पायटेस्ट अॅडव्हान्स्ड फिक्स्चर्समध्ये प्रभुत्व मिळवणे: पॅरामीटराइज्ड टेस्टिंग आणि मॉक इंटिग्रेशन

पायटेस्ट हे पायथनसाठी एक शक्तिशाली आणि लवचिक टेस्टिंग फ्रेमवर्क आहे. त्याची साधेपणा आणि विस्तारक्षमता यामुळे ते जगभरातील डेव्हलपर्समध्ये लोकप्रिय आहे. पायटेस्टच्या सर्वात आकर्षक वैशिष्ट्यांपैकी एक म्हणजे त्याची फिक्स्चर सिस्टीम, जी सुंदर आणि पुन्हा वापरण्यायोग्य टेस्ट सेटअपसाठी परवानगी देते. हा ब्लॉग पोस्ट अॅडव्हान्स्ड फिक्स्चर तंत्रांवर, विशेषतः पॅरामीटराइज्ड टेस्टिंग आणि मॉक इंटिग्रेशनवर लक्ष केंद्रित करतो. आम्ही पाहू की ही तंत्रे तुमच्या टेस्टिंग वर्कफ्लोला कशाप्रकारे लक्षणीयरीत्या सुधारू शकतात, ज्यामुळे अधिक मजबूत आणि देखरेख करण्यायोग्य कोड तयार होतो.

पायटेस्ट फिक्स्चर्स समजून घेणे

अॅडव्हान्स्ड विषयांमध्ये जाण्यापूर्वी, आपण पायटेस्ट फिक्स्चर्सच्या मूलभूत गोष्टींचा थोडक्यात आढावा घेऊ. फिक्स्चर हे एक फंक्शन आहे जे प्रत्येक टेस्ट फंक्शनच्या आधी चालते ज्यावर ते लागू केले जाते. याचा उपयोग टेस्टसाठी एक निश्चित आधाररेखा प्रदान करण्यासाठी केला जातो, ज्यामुळे सुसंगतता सुनिश्चित होते आणि बॉयलरप्लेट कोड कमी होतो. फिक्स्चर्स खालील कामे करू शकतात:

• डेटाबेस कनेक्शन सेट करणे
• तात्पुरत्या फाइल्स किंवा डिरेक्टरीज तयार करणे
• विशिष्ट कॉन्फिगरेशनसह ऑब्जेक्ट्स सुरू करणे
• API सह प्रमाणीकरण करणे

फिक्स्चर्स कोडच्या पुनर्वापराला प्रोत्साहन देतात आणि तुमच्या टेस्ट्सना अधिक वाचनीय आणि देखरेख करण्यायोग्य बनवतात. त्यांच्या लाइफटाइम आणि रिसोर्स वापराला नियंत्रित करण्यासाठी त्यांना वेगवेगळ्या स्कोपमध्ये (फंक्शन, मॉड्यूल, सेशन) परिभाषित केले जाऊ शकते.

साधे फिक्स्चरचे उदाहरण

येथे पायटेस्ट फिक्स्चरचे एक सोपे उदाहरण आहे जे एक तात्पुरती डिरेक्टरी तयार करते:

            
import pytest
import tempfile
import os

@pytest.fixture
def temp_dir():
    with tempfile.TemporaryDirectory() as tmpdir:
        yield tmpdir

            

              
                Copy
              
            
          

टेस्टमध्ये हे फिक्स्चर वापरण्यासाठी, फक्त तुमच्या टेस्ट फंक्शनमध्ये एक आर्गुमेंट म्हणून समाविष्ट करा:

            
def test_create_file(temp_dir):
    filepath = os.path.join(temp_dir, "test_file.txt")
    with open(filepath, "w") as f:
        f.write("Hello, world!")
    assert os.path.exists(filepath)

            

              
                Copy
              
            
          

पायटेस्टसह पॅरामीटराइज्ड टेस्टिंग

पॅरामीटराइज्ड टेस्टिंग तुम्हाला एकाच टेस्ट फंक्शनला वेगवेगळ्या इनपुट डेटाच्या सेटसह अनेक वेळा चालवण्याची परवानगी देते. हे विशेषतः वेगवेगळ्या इनपुट आणि अपेक्षित आउटपुटसह फंक्शन्सची चाचणी करण्यासाठी उपयुक्त आहे. पायटेस्ट पॅरामीटराइज्ड टेस्ट्स लागू करण्यासाठी @pytest.mark.parametrize डेकोरेटर प्रदान करते.

पॅरामीटराइज्ड टेस्टिंगचे फायदे

• कोडची पुनरावृत्ती कमी होते: अनेक जवळपास समान टेस्ट फंक्शन्स लिहिणे टाळा.
• टेस्ट कव्हरेज सुधारते: इनपुट व्हॅल्यूजच्या विस्तृत श्रेणीची सहज चाचणी घ्या.
• टेस्टची वाचनीयता वाढवते: प्रत्येक टेस्ट केससाठी इनपुट व्हॅल्यूज आणि अपेक्षित आउटपुट स्पष्टपणे परिभाषित करा.

साधे पॅरामीटरायझेशनचे उदाहरण

समजा तुमच्याकडे एक फंक्शन आहे जे दोन संख्यांची बेरीज करते:

            
def add(x, y):
    return x + y

            

              
                Copy
              
            
          

तुम्ही वेगवेगळ्या इनपुट व्हॅल्यूजसह या फंक्शनची चाचणी घेण्यासाठी पॅरामीटराइज्ड टेस्टिंग वापरू शकता:

            
import pytest

@pytest.mark.parametrize("x, y, expected", [
    (1, 2, 3),
    (5, 5, 10),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_add(x, y, expected):
    assert add(x, y) == expected

            

              
                Copy
              
            
          

या उदाहरणात, @pytest.mark.parametrize डेकोरेटर चार टेस्ट केसेस परिभाषित करतो, प्रत्येकामध्ये x, y आणि अपेक्षित परिणामासाठी भिन्न मूल्ये आहेत. पायटेस्ट test_add फंक्शन चार वेळा चालवेल, प्रत्येक पॅरामीटर्सच्या सेटसाठी एकदा.

अॅडव्हान्स्ड पॅरामीटरायझेशन तंत्र

पायटेस्ट पॅरामीटरायझेशनसाठी अनेक अॅडव्हान्स्ड तंत्रे ऑफर करते, ज्यात खालील गोष्टींचा समावेश आहे:

• पॅरामीटरायझेशनसह फिक्स्चर्स वापरणे: प्रत्येक टेस्ट केससाठी वेगवेगळे सेटअप प्रदान करण्यासाठी फिक्स्चर्सला पॅरामीटरायझेशनसह एकत्र करा.
• टेस्ट केसेससाठी आयडी (Ids): उत्तम रिपोर्टिंग आणि डीबगिंगसाठी टेस्ट केसेसना कस्टम आयडी द्या.
• इनडायरेक्ट पॅरामीटरायझेशन: फिक्स्चर्सना पास केलेल्या आर्गुमेंट्सना पॅरामीटराइज करा, ज्यामुळे डायनॅमिक फिक्स्चर तयार करता येते.

पॅरामीटरायझेशनसह फिक्स्चर्स वापरणे

हे तुम्हाला टेस्टला पास केलेल्या पॅरामीटर्सवर आधारित फिक्स्चर्स डायनॅमिकरित्या कॉन्फिगर करण्याची परवानगी देते. कल्पना करा की तुम्ही डेटाबेसशी संवाद साधणाऱ्या फंक्शनची चाचणी करत आहात. तुम्हाला वेगवेगळ्या टेस्ट केसेससाठी वेगवेगळे डेटाबेस कॉन्फिगरेशन (उदा. भिन्न कनेक्शन स्ट्रिंग्स) वापरायचे असतील.

            
import pytest

@pytest.fixture
def db_config(request):
    if request.param == "prod":
        return {"host": "prod.example.com", "port": 5432}
    elif request.param == "test":
        return {"host": "test.example.com", "port": 5433}
    else:
        raise ValueError("Invalid database environment")


@pytest.fixture
def db_connection(db_config):
    # Simulate establishing a database connection
    print(f"Connecting to database at {db_config['host']}:{db_config['port']}")
    return f"Connection to {db_config['host']}"


@pytest.mark.parametrize("db_config", ["prod", "test"], indirect=True)
def test_database_interaction(db_connection):
    # Your test logic here, using the db_connection fixture
    print(f"Using connection: {db_connection}")
    assert "Connection" in db_connection

            

              
                Copy
              
            
          

या उदाहरणात, db_config फिक्स्चर पॅरामीटराइज्ड आहे. indirect=True हे आर्गुमेंट पायटेस्टला पॅरामीटर्स ("prod" आणि "test") db_config फिक्स्चर फंक्शनला पास करण्यास सांगते. db_config फिक्स्चर नंतर पॅरामीटर व्हॅल्यूवर आधारित भिन्न डेटाबेस कॉन्फिगरेशन परत करते. db_connection फिक्स्चर डेटाबेस कनेक्शन स्थापित करण्यासाठी db_config फिक्स्चर वापरते. शेवटी, test_database_interaction फंक्शन डेटाबेसशी संवाद साधण्यासाठी db_connection फिक्स्चर वापरते.

टेस्ट केसेससाठी आयडी (Ids)

कस्टम आयडी तुमच्या टेस्ट केसेससाठी टेस्ट रिपोर्टमध्ये अधिक वर्णनात्मक नावे प्रदान करतात, ज्यामुळे अपयश ओळखणे आणि डीबग करणे सोपे होते.

            
import pytest

@pytest.mark.parametrize(
    "input_string, expected_output",
    [
        ("hello", "HELLO"),
        ("world", "WORLD"),
        ("", ""),
    ],
    ids=["lowercase_hello", "lowercase_world", "empty_string"],
)
def test_uppercase(input_string, expected_output):
    assert input_string.upper() == expected_output

            

              
                Copy
              
            
          

आयडींशिवाय, पायटेस्ट test_uppercase[0], test_uppercase[1], इत्यादी सामान्य नावे तयार करेल. आयडींसह, टेस्ट रिपोर्ट test_uppercase[lowercase_hello] सारखी अधिक अर्थपूर्ण नावे दर्शवेल.

इनडायरेक्ट पॅरामीटरायझेशन

इनडायरेक्ट पॅरामीटरायझेशन तुम्हाला थेट टेस्ट फंक्शनऐवजी फिक्स्चरच्या इनपुटला पॅरामीटराइज करण्याची परवानगी देते. जेव्हा तुम्हाला पॅरामीटर व्हॅल्यूवर आधारित भिन्न फिक्स्चर इन्स्टन्स तयार करायचे असतील तेव्हा हे उपयुक्त ठरते.

            
import pytest

@pytest.fixture
def input_data(request):
    if request.param == "valid":
        return {"name": "John Doe", "email": "john.doe@example.com"}
    elif request.param == "invalid":
        return {"name": "", "email": "invalid-email"}
    else:
        raise ValueError("Invalid input data type")


def validate_data(data):
    if not data["name"]:
        return False, "Name cannot be empty"
    if "@" not in data["email"]:
        return False, "Invalid email address"
    return True, "Valid data"

@pytest.mark.parametrize("input_data", ["valid", "invalid"], indirect=True)
def test_validate_data(input_data):
    is_valid, message = validate_data(input_data)
    if input_data == {"name": "John Doe", "email": "john.doe@example.com"}:
        assert is_valid is True
        assert message == "Valid data"
    else:
        assert is_valid is False
        assert message in ["Name cannot be empty", "Invalid email address"]

            

              
                Copy
              
            
          

या उदाहरणात, input_data फिक्स्चर "valid" आणि "invalid" व्हॅल्यूजसह पॅरामीटराइज्ड आहे. indirect=True हे आर्गुमेंट पायटेस्टला या व्हॅल्यूज input_data फिक्स्चर फंक्शनला पास करण्यास सांगते. input_data फिक्स्चर नंतर पॅरामीटर व्हॅल्यूवर आधारित भिन्न डेटा डिक्शनरीज परत करते. test_validate_data फंक्शन नंतर भिन्न इनपुट डेटासह validate_data फंक्शनची चाचणी घेण्यासाठी input_data फिक्स्चर वापरते.

पायटेस्टसह मॉकिंग

मॉकिंग हे एक तंत्र आहे जे टेस्टिंग दरम्यान वास्तविक अवलंबित्व (dependencies) नियंत्रित पर्यायांसह (mocks) बदलण्यासाठी वापरले जाते. हे तुम्हाला चाचणी अंतर्गत असलेल्या कोडला वेगळे करण्यास आणि डेटाबेस, API किंवा फाइल सिस्टीमसारख्या बाह्य प्रणालींवर अवलंबून राहणे टाळण्यास मदत करते.

मॉकिंगचे फायदे

• कोड वेगळे करणे: बाह्य अवलंबनांवर अवलंबून न राहता, कोडची स्वतंत्रपणे चाचणी करा.
• वर्तनावर नियंत्रण: अवलंबनांचे वर्तन परिभाषित करा, जसे की रिटर्न व्हॅल्यूज आणि एक्सेप्शन्स.
• टेस्टची गती वाढवणे: धीम्या किंवा अविश्वसनीय बाह्य प्रणाली टाळा.
• एज केसेसची चाचणी: वास्तविक वातावरणात पुनरुत्पादित करणे कठीण असलेल्या त्रुटी परिस्थिती आणि एज केसेसचे अनुकरण करा.

unittest.mock लायब्ररी वापरणे

पायथन मॉक्स तयार करण्यासाठी unittest.mock लायब्ररी प्रदान करते. पायटेस्ट unittest.mock सह अखंडपणे समाकलित होते, ज्यामुळे तुमच्या टेस्टमध्ये अवलंबित्व मॉक करणे सोपे होते.

साधे मॉकिंगचे उदाहरण

समजा तुमच्याकडे एक फंक्शन आहे जे बाह्य API मधून डेटा मिळवते:

            
import requests

def get_data_from_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Raise an exception for bad status codes
    return response.json()

            

              
                Copy
              
            
          

या फंक्शनची प्रत्यक्षात API ला रिक्वेस्ट न करता चाचणी घेण्यासाठी, तुम्ही requests.get फंक्शन मॉक करू शकता:

            
import pytest
import requests
from unittest.mock import patch

@patch("requests.get")
def test_get_data_from_api(mock_get):
    # Configure the mock to return a specific response
    mock_get.return_value.json.return_value = {"data": "test data"}
    mock_get.return_value.status_code = 200

    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    mock_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

या उदाहरणात, @patch("requests.get") डेकोरेटर requests.get फंक्शनला मॉक ऑब्जेक्टने बदलतो. mock_get आर्गुमेंट हे मॉक ऑब्जेक्ट आहे. त्यानंतर आपण मॉक ऑब्जेक्टला विशिष्ट प्रतिसाद देण्यासाठी कॉन्फिगर करू शकतो आणि ते योग्य URL सह कॉल केले गेले होते याची खात्री करू शकतो.

फिक्स्चर्ससह मॉकिंग

तुम्ही मॉक्स तयार करण्यासाठी आणि व्यवस्थापित करण्यासाठी फिक्स्चर्सचा वापर देखील करू शकता. हे अनेक टेस्टमध्ये मॉक्स शेअर करण्यासाठी किंवा अधिक जटिल मॉक सेटअप तयार करण्यासाठी उपयुक्त ठरू शकते.

            
import pytest
import requests
from unittest.mock import Mock

@pytest.fixture
def mock_api_get():
    mock = Mock()
    mock.return_value.json.return_value = {"data": "test data"}
    mock.return_value.status_code = 200
    return mock


@pytest.fixture
def patched_get(mock_api_get, monkeypatch):
    monkeypatch.setattr(requests, "get", mock_api_get)
    return mock_api_get


def test_get_data_from_api(patched_get):
    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    patched_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

येथे, mock_api_get एक मॉक तयार करते आणि ते परत करते. patched_get नंतर monkeypatch, एक पायटेस्ट फिक्स्चर, वापरून वास्तविक `requests.get` ला मॉकसह बदलते. हे इतर टेस्टना समान मॉक केलेले API एंडपॉइंट वापरण्याची परवानगी देते.

अॅडव्हान्स्ड मॉकिंग तंत्र

पायटेस्ट आणि unittest.mock अनेक अॅडव्हान्स्ड मॉकिंग तंत्रे ऑफर करतात, ज्यात खालील गोष्टींचा समावेश आहे:

• साइड इफेक्ट्स (Side Effects): इनपुट आर्गुमेंट्सवर आधारित मॉक्ससाठी कस्टम वर्तन परिभाषित करा.
• प्रॉपर्टी मॉकिंग: ऑब्जेक्ट्सच्या प्रॉपर्टीज मॉक करा.
• कन्टेक्स्ट मॅनेजर्स: तात्पुरत्या बदलांसाठी कन्टेक्स्ट मॅनेजर्समध्ये मॉक्स वापरा.

साइड इफेक्ट्स (Side Effects)

साइड इफेक्ट्स तुम्हाला तुमच्या मॉक्ससाठी त्यांच्या इनपुट आर्गुमेंट्सवर आधारित कस्टम वर्तन परिभाषित करण्याची परवानगी देतात. हे विविध परिस्थिती किंवा त्रुटी परिस्थितींचे अनुकरण करण्यासाठी उपयुक्त आहे.

            
import pytest
from unittest.mock import Mock

def test_side_effect():
    mock = Mock()
    mock.side_effect = [1, 2, 3]

    assert mock() == 1
    assert mock() == 2
    assert mock() == 3
    with pytest.raises(StopIteration):
        mock()

            

              
                Copy
              
            
          

हे मॉक सलग कॉल्सवर १, २ आणि ३ परत करते, नंतर जेव्हा लिस्ट संपते तेव्हा `StopIteration` एक्सेप्शन रेज करते.

प्रॉपर्टी मॉकिंग

प्रॉपर्टी मॉकिंग तुम्हाला ऑब्जेक्ट्सवरील प्रॉपर्टीजचे वर्तन मॉक करण्याची परवानगी देते. हे मेथड्सऐवजी ऑब्जेक्ट प्रॉपर्टीजवर अवलंबून असलेल्या कोडची चाचणी करण्यासाठी उपयुक्त आहे.

            
import pytest
from unittest.mock import patch

class MyClass:
    @property
    def my_property(self):
        return "original value"


def test_property_mocking():
    obj = MyClass()
    with patch.object(obj, "my_property", new_callable=pytest.PropertyMock) as mock_property:
        mock_property.return_value = "mocked value"
        assert obj.my_property == "mocked value"

            

              
                Copy
              
            
          

हे उदाहरण MyClass ऑब्जेक्टच्या my_property प्रॉपर्टीला मॉक करते, ज्यामुळे तुम्हाला टेस्ट दरम्यान त्याचे रिटर्न व्हॅल्यू नियंत्रित करता येते.

कन्टेक्स्ट मॅनेजर्स

कन्टेक्स्ट मॅनेजर्समध्ये मॉक्स वापरल्याने तुम्हाला कोडच्या विशिष्ट ब्लॉकसाठी तात्पुरते अवलंबित्व बदलण्याची परवानगी मिळते. हे बाह्य प्रणाली किंवा संसाधनांशी संवाद साधणाऱ्या कोडची चाचणी करण्यासाठी उपयुक्त आहे जे केवळ मर्यादित कालावधीसाठी मॉक केले पाहिजेत.

            
import pytest
from unittest.mock import patch


def test_context_manager_mocking():
    with patch("os.path.exists") as mock_exists:
        mock_exists.return_value = True
        assert os.path.exists("dummy_path") is True
    # The mock is automatically reverted after the 'with' block
    # Ensure the original function is restored, although we can't really assert
    # the real `os.path.exists` function's behavior without a real path.
    # The important thing is that the patch is gone after the context.
    print("Mock has been removed")

            

              
                Copy
              
            
          

पॅरामीटरायझेशन आणि मॉकिंग एकत्र करणे

ही दोन शक्तिशाली तंत्रे एकत्र करून आणखी अत्याधुनिक आणि प्रभावी टेस्ट तयार केल्या जाऊ शकतात. तुम्ही भिन्न मॉक कॉन्फिगरेशनसह भिन्न परिस्थितींची चाचणी घेण्यासाठी पॅरामीटरायझेशन वापरू शकता.

            
import pytest
import requests
from unittest.mock import patch


def get_user_data(user_id):
    url = f"https://api.example.com/users/{user_id}"
    response = requests.get(url)
    response.raise_for_status()
    return response.json()


@pytest.mark.parametrize(
    "user_id, expected_data",
    [
        (1, {"id": 1, "name": "John Doe"}),
        (2, {"id": 2, "name": "Jane Smith"}),
    ],
)
@patch("requests.get")
def test_get_user_data(mock_get, user_id, expected_data):
    mock_get.return_value.json.return_value = expected_data
    mock_get.return_value.status_code = 200

    data = get_user_data(user_id)

    assert data == expected_data
    mock_get.assert_called_once_with(f"https://api.example.com/users/{user_id}")

            

              
                Copy
              
            
          

या उदाहरणात, test_get_user_data फंक्शन भिन्न user_id आणि expected_data व्हॅल्यूजसह पॅरामीटराइज्ड आहे. @patch डेकोरेटर requests.get फंक्शनला मॉक करतो. पायटेस्ट टेस्ट फंक्शन दोनदा चालवेल, प्रत्येक पॅरामीटर्सच्या सेटसाठी एकदा, संबंधित expected_data परत करण्यासाठी मॉक कॉन्फिगर करून.

अॅडव्हान्स्ड फिक्स्चर्स वापरण्यासाठी सर्वोत्तम पद्धती

• फिक्स्चर्स केंद्रित ठेवा: प्रत्येक फिक्स्चरचा एक स्पष्ट आणि विशिष्ट उद्देश असावा.
• योग्य स्कोप वापरा: संसाधनांचा वापर ऑप्टिमाइझ करण्यासाठी योग्य फिक्स्चर स्कोप (फंक्शन, मॉड्यूल, सेशन) निवडा.
• फिक्स्चर्सचे डॉक्युमेंटेशन करा: प्रत्येक फिक्स्चरचा उद्देश आणि वापर स्पष्टपणे डॉक्युमेंट करा.
• अति-मॉकिंग टाळा: फक्त त्याच अवलंबनांना मॉक करा जे चाचणी अंतर्गत कोडला वेगळे करण्यासाठी आवश्यक आहेत.
• स्पष्ट असर्शन्स लिहा: तुमची असर्शन्स स्पष्ट आणि विशिष्ट असल्याची खात्री करा, चाचणी अंतर्गत कोडच्या अपेक्षित वर्तनाची पडताळणी करा.
• टेस्ट-ड्रिव्हन डेव्हलपमेंट (TDD) चा विचार करा: कोड लिहिण्यापूर्वी तुमच्या टेस्ट लिहा, विकास प्रक्रियेला मार्गदर्शन करण्यासाठी फिक्स्चर्स आणि मॉक्सचा वापर करा.

निष्कर्ष

पायटेस्टची अॅडव्हान्स्ड फिक्स्चर तंत्रे, ज्यात पॅरामीटराइज्ड टेस्टिंग आणि मॉक इंटिग्रेशन यांचा समावेश आहे, मजबूत, कार्यक्षम आणि देखरेख करण्यायोग्य टेस्ट लिहिण्यासाठी शक्तिशाली साधने प्रदान करतात. या तंत्रांवर प्रभुत्व मिळवून, तुम्ही तुमच्या पायथन कोडची गुणवत्ता लक्षणीयरीत्या सुधारू शकता आणि तुमचा टेस्टिंग वर्कफ्लो सुव्यवस्थित करू शकता. स्पष्ट, केंद्रित फिक्स्चर्स तयार करणे, योग्य स्कोप वापरणे आणि सर्वसमावेशक असर्शन्स लिहिण्यावर लक्ष केंद्रित करण्याचे लक्षात ठेवा. सरावाने, तुम्ही एक व्यापक आणि प्रभावी टेस्टिंग स्ट्रॅटेजी तयार करण्यासाठी पायटेस्टच्या फिक्स्चर सिस्टीमच्या पूर्ण क्षमतेचा फायदा घेऊ शकाल.